﻿namespace AC.ExtendedRenderer.Toolkit
{
    using ComponentFactory.Krypton.Toolkit;
    using System;
    using System.ComponentModel;
    using System.ComponentModel.Design;
    using System.Data;
    using System.Drawing;
    using System.Drawing.Design;
    using System.Runtime.CompilerServices;
    using System.Runtime.InteropServices;
    using System.Windows.Forms;
    using System.Windows.Forms.Design;
    using System.Windows.Forms.VisualStyles;

    [ComplexBindingProperties, Docking(DockingBehavior.Ask), DesignerCategory("code"), Designer(typeof(ControlDesigner))]
    public class KryptonTreeGridView : KryptonDataGridView
    {
        private bool _disposing;
        private TreeGridColumn _expandableColumn;
        internal System.Windows.Forms.ImageList _imageList;
        private int _indentWidth;
        private bool _inExpandCollapse;
        internal bool _inExpandCollapseMouseCapture;
        private string _parentIDColumnName;
        private TreeGridNode _root;
        private bool _showLines = true;
        private bool _virtualNodes;
        private DataTable dataSource;
        private bool fontParentBold;
        private int groupByColumnIndex;
        private Control hideScrollBarControl;
        private string iDColumnName;
        private int imageIndexChild;
        private int imageIndexParent;
        private bool isOneLevel;
        internal VisualStyleRenderer rClosed = new VisualStyleRenderer(VisualStyleElement.TreeView.Glyph.Closed);
        internal VisualStyleRenderer rOpen = new VisualStyleRenderer(VisualStyleElement.TreeView.Glyph.Opened);
        private bool useParentRelationship;

        public event CollapsedEventHandler NodeCollapsed;

        public event CollapsingEventHandler NodeCollapsing;

        public event ExpandedEventHandler NodeExpanded;

        public event ExpandingEventHandler NodeExpanding;

        public KryptonTreeGridView()
        {
            base.EditMode = DataGridViewEditMode.EditProgrammatically;
            this.RowTemplate = new TreeGridNode();
            base.AllowUserToAddRows = false;
            base.AllowUserToDeleteRows = false;
            this._root = new TreeGridNode(this);
            this._root.IsRoot = true;
            base.Rows.CollectionChanged += delegate (object sender, CollectionChangeEventArgs e) {
            };
        }

        private void BuildPortsNodes(bool FirstLoop, string Item_Id, DataTable dt, string IDColumnName, string ParentIDColumnName, int UniqueId)
        {
            int num = 0;
            DataView view = new DataView(dt);
            if (FirstLoop)
            {
                view.RowFilter = IDColumnName + "=" + ParentIDColumnName;
                TreeGridNode node = new TreeGridNode();
                UniqueId = node.UniqueValue;
            }
            else
            {
                view.RowFilter = ParentIDColumnName + "=" + Item_Id + " AND " + IDColumnName + "<>" + Item_Id;
            }
            if (view.Count > 0)
            {
                try
                {
                    num = 0;
                    while (num <= (view.Count - 1))
                    {
                        string[] values = new string[dt.Columns.Count];
                        for (int i = 0; i < dt.Columns.Count; i++)
                        {
                            values[i] = view[num][i].ToString().Trim();
                        }
                        TreeGridNode node2 = new TreeGridNode();
                        TreeGridNode nodeByUniqueValue = this.Nodes.GetNodeByUniqueValue(UniqueId);
                        if (nodeByUniqueValue.UniqueValue == -10)
                        {
                            nodeByUniqueValue = new TreeGridNode();
                        }
                        UniqueId = nodeByUniqueValue.Nodes.Add(values).UniqueValue;
                        this.BuildPortsNodes(false, view[num][IDColumnName].ToString(), dt, IDColumnName, ParentIDColumnName, UniqueId);
                        num++;
                    }
                }
                catch (Exception exception)
                {
                    MessageBox.Show(string.Concat(new object[] { "Failed to add item ", num, " : ", exception.Message }), " ", MessageBoxButtons.OK, MessageBoxIcon.Hand);
                }
            }
        }

        private void BuildPortsNodesInitialLoop(string Item_Id, DataTable dt, string IDColumnName, string ParentIDColumnName, int UniqueId)
        {
            int num = 0;
            DataView view = new DataView(dt);
            view.RowFilter = IDColumnName + "=" + ParentIDColumnName;
            TreeGridNode parentNode = new TreeGridNode();
            if (view.Count > 0)
            {
                for (num = 0; num <= (view.Count - 1); num++)
                {
                    string[] values = new string[dt.Columns.Count];
                    for (int i = 0; i < dt.Columns.Count; i++)
                    {
                        values[i] = view[num][i].ToString().Trim();
                    }
                    parentNode = this.Nodes.Add(values);
                    string str = view[num][IDColumnName].ToString();
                    this.BuildPortsNodesOtherLoops(str, dt, IDColumnName, ParentIDColumnName, ref parentNode);
                }
            }
        }

        private void BuildPortsNodesOtherLoops(string Item_Id, DataTable dt, string IDColumnName, string ParentIDColumnName, ref TreeGridNode parentNode)
        {
            int num = 0;
            DataView view = new DataView(dt);
            view.RowFilter = ParentIDColumnName + "=" + Item_Id + " AND " + IDColumnName + "<>" + ParentIDColumnName;
            TreeGridNode node = parentNode;
            if (view.Count > 0)
            {
                node.ImageIndex = this.imageIndexParent;
                if (this.fontParentBold)
                {
                    node.DefaultCellStyle.Font = new Font(base.DefaultCellStyle.Font, FontStyle.Bold);
                }
                for (num = 0; num <= (view.Count - 1); num++)
                {
                    string[] values = new string[dt.Columns.Count];
                    for (int i = 0; i < dt.Columns.Count; i++)
                    {
                        values[i] = view[num][i].ToString().Trim();
                    }
                    TreeGridNode node2 = new TreeGridNode();
                    node2 = node.Nodes.Add(values);
                    string str = view[num][IDColumnName].ToString();
                    this.BuildPortsNodesOtherLoops(str, dt, IDColumnName, ParentIDColumnName, ref node2);
                }
            }
            else
            {
                node.ImageIndex = this.imageIndexChild;
            }
        }

        [Description("Collapse all nodes")]
        public void CollapseAll()
        {
            foreach (TreeGridNode node in this.Nodes)
            {
                this.collapseNode(node);
            }
        }

        private void collapseNode(TreeGridNode node)
        {
            if (node.Nodes.Count > 0)
            {
                foreach (TreeGridNode node2 in node.Nodes)
                {
                    this.collapseNode(node2);
                }
                node.Collapse();
            }
        }

        protected internal virtual bool CollapseNode(TreeGridNode node)
        {
            if (!node.IsExpanded)
            {
                return false;
            }
            CollapsingEventArgs e = new CollapsingEventArgs(node);
            this.OnNodeCollapsing(e);
            if (!e.Cancel)
            {
                this.LockVerticalScrollBarUpdate(true);
                base.SuspendLayout();
                this._inExpandCollapse = true;
                node.IsExpanded = false;
                foreach (TreeGridNode node2 in node.Nodes)
                {
                    this.UnSiteNode(node2);
                }
                CollapsedEventArgs args2 = new CollapsedEventArgs(node);
                this.OnNodeCollapsed(args2);
                this._inExpandCollapse = false;
                this.LockVerticalScrollBarUpdate(false);
                base.ResumeLayout(true);
                base.InvalidateCell(node.Cells[0]);
            }
            return !e.Cancel;
        }

        protected override void Dispose(bool disposing)
        {
            this._disposing = true;
            base.Dispose(base.Disposing);
            this.UnSiteAll();
        }

        [Description("Expands all nodes")]
        public void ExpandAll()
        {
            foreach (TreeGridNode node in this.Nodes)
            {
                this.expandNode(node);
            }
        }

        private void expandNode(TreeGridNode node)
        {
            if (node.Nodes.Count > 0)
            {
                node.Expand();
                foreach (TreeGridNode node2 in node.Nodes)
                {
                    this.expandNode(node2);
                }
            }
        }

        protected internal virtual bool ExpandNode(TreeGridNode node)
        {
            if (node.IsExpanded && !this._virtualNodes)
            {
                return false;
            }
            ExpandingEventArgs e = new ExpandingEventArgs(node);
            this.OnNodeExpanding(e);
            if (!e.Cancel)
            {
                this.LockVerticalScrollBarUpdate(true);
                base.SuspendLayout();
                this._inExpandCollapse = true;
                node.IsExpanded = true;
                foreach (TreeGridNode node2 in node.Nodes)
                {
                    this.SiteNode(node2);
                }
                ExpandedEventArgs args2 = new ExpandedEventArgs(node);
                this.OnNodeExpanded(args2);
                this._inExpandCollapse = false;
                this.LockVerticalScrollBarUpdate(false);
                base.ResumeLayout(true);
                base.InvalidateCell(node.Cells[0]);
            }
            return !e.Cancel;
        }

        public static DataTable FilterSortData(DataTable dtStart, string filter, string sort)
        {
            DataTable table = dtStart.Clone();
            foreach (DataRow row in dtStart.Select(filter, sort))
            {
                table.ImportRow(row);
            }
            dtStart.Dispose();
            return table;
        }

        [Description("Returns the TreeGridNode for the given DataGridViewRow")]
        public TreeGridNode GetNodeForRow(int index)
        {
            return this.GetNodeForRow(base.Rows[index]);
        }

        [Description("Returns the TreeGridNode for the given DataGridViewRow")]
        public TreeGridNode GetNodeForRow(DataGridViewRow row)
        {
            return (row as TreeGridNode);
        }

        private void LockVerticalScrollBarUpdate(bool lockUpdate)
        {
            if (!this._inExpandCollapse)
            {
                if (lockUpdate)
                {
                    base.VerticalScrollBar.Parent = this.hideScrollBarControl;
                }
                else
                {
                    base.VerticalScrollBar.Parent = this;
                }
            }
        }

        protected override void OnColumnAdded(DataGridViewColumnEventArgs e)
        {
            if (typeof(TreeGridColumn).IsAssignableFrom(e.Column.GetType()) && (this._expandableColumn == null))
            {
                this._expandableColumn = (TreeGridColumn) e.Column;
            }
            e.Column.SortMode = DataGridViewColumnSortMode.NotSortable;
            base.OnColumnAdded(e);
        }

        protected override void OnHandleCreated(EventArgs e)
        {
            base.OnHandleCreated(e);
            this.hideScrollBarControl = new Control();
            this.hideScrollBarControl.Visible = false;
            this.hideScrollBarControl.Enabled = false;
            this.hideScrollBarControl.TabStop = false;
            base.Controls.Add(this.hideScrollBarControl);
        }

        protected override void OnKeyDown(KeyEventArgs e)
        {
            base.OnKeyDown(e);
            if (!e.Handled)
            {
                if (((e.KeyCode == Keys.F2) && (base.CurrentCellAddress.X > -1)) && (base.CurrentCellAddress.Y > -1))
                {
                    if (!base.CurrentCell.Displayed)
                    {
                        base.FirstDisplayedScrollingRowIndex = base.CurrentCellAddress.Y;
                    }
                    base.SelectionMode = DataGridViewSelectionMode.CellSelect;
                    this.BeginEdit(true);
                }
                else if ((e.KeyCode == Keys.Return) && !base.IsCurrentCellInEditMode)
                {
                    base.SelectionMode = DataGridViewSelectionMode.FullRowSelect;
                    base.CurrentCell.OwningRow.Selected = true;
                }
            }
        }

        protected override void OnMouseMove(MouseEventArgs e)
        {
            if (!this._inExpandCollapseMouseCapture)
            {
                base.OnMouseMove(e);
            }
        }

        protected override void OnMouseUp(MouseEventArgs e)
        {
            base.OnMouseUp(e);
            this._inExpandCollapseMouseCapture = false;
        }

        protected virtual void OnNodeCollapsed(CollapsedEventArgs e)
        {
            if (this.NodeCollapsed != null)
            {
                this.NodeCollapsed(this, e);
            }
        }

        protected virtual void OnNodeCollapsing(CollapsingEventArgs e)
        {
            if (this.NodeCollapsing != null)
            {
                this.NodeCollapsing(this, e);
            }
        }

        protected virtual void OnNodeExpanded(ExpandedEventArgs e)
        {
            if (this.NodeExpanded != null)
            {
                this.NodeExpanded(this, e);
            }
        }

        protected virtual void OnNodeExpanding(ExpandingEventArgs e)
        {
            if (this.NodeExpanding != null)
            {
                this.NodeExpanding(this, e);
            }
        }

        protected override void OnRowEnter(DataGridViewCellEventArgs e)
        {
            base.OnRowEnter(e);
            if ((base.SelectionMode == DataGridViewSelectionMode.CellSelect) || ((base.SelectionMode == DataGridViewSelectionMode.FullRowSelect) && !base.Rows[e.RowIndex].Selected))
            {
                base.SelectionMode = DataGridViewSelectionMode.FullRowSelect;
                base.Rows[e.RowIndex].Selected = true;
            }
        }

        protected override void OnRowsAdded(DataGridViewRowsAddedEventArgs e)
        {
            base.OnRowsAdded(e);
            for (int i = e.RowCount - 1; i >= 0; i--)
            {
                TreeGridNode node = base.Rows[e.RowIndex + i] as TreeGridNode;
                if (node != null)
                {
                    node.Sited();
                }
            }
        }

        protected internal virtual void SiteNode(TreeGridNode node)
        {
            TreeGridNode parent;
            int index = -1;
            node._grid = this;
            if ((node.Parent != null) && !node.Parent.IsRoot)
            {
                if (node.Index > 0)
                {
                    parent = node.Parent.Nodes[node.Index - 1];
                }
                else
                {
                    parent = node.Parent;
                }
            }
            else if (node.Index > 0)
            {
                parent = node.Parent.Nodes[node.Index - 1];
            }
            else
            {
                parent = null;
            }
            if (parent == null)
            {
                index = 0;
            }
            else
            {
                while (parent.Level >= node.Level)
                {
                    if (parent.RowIndex >= (base.Rows.Count - 1))
                    {
                        break;
                    }
                    parent = base.Rows[parent.RowIndex + 1] as TreeGridNode;
                }
                if (parent == node.Parent)
                {
                    index = parent.RowIndex + 1;
                }
                else if (parent.Level < node.Level)
                {
                    index = parent.RowIndex;
                }
                else
                {
                    index = parent.RowIndex + 1;
                }
            }
            this.SiteNode(node, index);
            if (node.IsExpanded)
            {
                foreach (TreeGridNode node3 in node.Nodes)
                {
                    this.SiteNode(node3);
                }
            }
        }

        protected internal virtual void SiteNode(TreeGridNode node, int index)
        {
            if (index < base.Rows.Count)
            {
                base.Rows.Insert(index, node);
            }
            else
            {
                base.Rows.Add(node);
            }
        }

        protected internal void UnSiteAll()
        {
            this.UnSiteNode(this._root);
        }

        protected internal virtual void UnSiteNode(TreeGridNode node)
        {
            if (node.IsSited || node.IsRoot)
            {
                foreach (TreeGridNode node2 in node.Nodes)
                {
                    this.UnSiteNode(node2);
                }
                if (!node.IsRoot)
                {
                    try
                    {
                        base.Rows.Remove(node);
                        node.UnSited();
                    }
                    catch
                    {
                    }
                }
            }
        }

        public TreeGridNode CurrentNode
        {
            get
            {
                return this.CurrentRow;
            }
        }

        public TreeGridNode CurrentRow
        {
            get
            {
                return (base.CurrentRow as TreeGridNode);
            }
        }

        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
        public object DataMember
        {
            get
            {
                return null;
            }
            set
            {
                throw new NotSupportedException("The TreeGridView does not support databinding");
            }
        }

        [Browsable(true), RefreshProperties(RefreshProperties.Repaint), AttributeProvider(typeof(IListSource)), DefaultValue(""), Category("Appearance-Extended")]
        public DataTable DataSource
        {
            get
            {
                return this.dataSource;
            }
            set
            {
                if (value != null)
                {
                    this.dataSource = value;
                    this.Nodes.Clear();
                    base.Columns.Clear();
                    if (this.groupByColumnIndex != 0)
                    {
                        this.dataSource.Columns[this.groupByColumnIndex].SetOrdinal(0);
                    }
                    this.dataSource = FilterSortData(this.dataSource, "", this.dataSource.Columns[0].ColumnName);
                    for (int i = 0; i < this.dataSource.Columns.Count; i++)
                    {
                        if (i == 0)
                        {
                            TreeGridColumn dataGridViewColumn = new TreeGridColumn();
                            dataGridViewColumn.HeaderText = this.dataSource.Columns[i].ColumnName;
                            dataGridViewColumn.DataPropertyName = this.dataSource.Columns[i].ColumnName;
                            dataGridViewColumn.AutoSizeMode = DataGridViewAutoSizeColumnMode.None;
                            base.Columns.Add(dataGridViewColumn);
                        }
                        else
                        {
                            DataGridViewTextBoxColumn column2 = new DataGridViewTextBoxColumn();
                            column2.HeaderText = this.dataSource.Columns[i].ColumnName;
                            column2.DataPropertyName = this.dataSource.Columns[i].ColumnName;
                            column2.AutoSizeMode = DataGridViewAutoSizeColumnMode.None;
                            base.Columns.Add(column2);
                        }
                    }
                    if (this.useParentRelationship)
                    {
                        this.dataSource = FilterSortData(this.dataSource, "", this._parentIDColumnName);
                        this.BuildPortsNodesInitialLoop("", this.dataSource, this.iDColumnName, this._parentIDColumnName, 0);
                    }
                    else
                    {
                        Font font = new Font(base.DefaultCellStyle.Font, FontStyle.Bold);
                        bool flag = false;
                        TreeGridNode node = new TreeGridNode();
                        TreeGridNode node2 = new TreeGridNode();
                        string[] strArray = new string[this.dataSource.Columns.Count];
                        int num2 = 0;
                        foreach (DataRow row in this.dataSource.Rows)
                        {
                            string[] values = new string[this.dataSource.Columns.Count];
                            for (int j = 0; j < this.dataSource.Columns.Count; j++)
                            {
                                values[j] = row[j].ToString().Trim();
                                if (((num2 > 0) && (j == 0)) && (values[j] == strArray[j]))
                                {
                                    flag = true;
                                }
                            }
                            if (flag)
                            {
                                if (this.isOneLevel)
                                {
                                    node = node2.Nodes.Add(values);
                                    node.ImageIndex = this.imageIndexChild;
                                    if (this.fontParentBold)
                                    {
                                        node2.DefaultCellStyle.Font = new Font(base.DefaultCellStyle.Font, FontStyle.Bold);
                                    }
                                    node2.ImageIndex = this.imageIndexParent;
                                }
                                else
                                {
                                    node = node.Nodes.Add(values);
                                    node.ImageIndex = this.imageIndexChild;
                                    node2.ImageIndex = this.imageIndexParent;
                                }
                                flag = false;
                            }
                            else if (this.isOneLevel)
                            {
                                node2 = new TreeGridNode();
                                node2 = this.Nodes.Add(values);
                                node2.ImageIndex = this.imageIndexChild;
                            }
                            else
                            {
                                node = new TreeGridNode();
                                node = this.Nodes.Add(values);
                                node.ImageIndex = this.imageIndexParent;
                                if (this.fontParentBold)
                                {
                                    node.DefaultCellStyle.Font = new Font(base.DefaultCellStyle.Font, FontStyle.Bold);
                                }
                            }
                            num2++;
                            strArray = (string[]) values.Clone();
                        }
                        font.Dispose();
                    }
                }
            }
        }

        [RefreshProperties(RefreshProperties.Repaint), Category("Appearance-Extended"), Browsable(true), DefaultValue(true)]
        public bool FontParentBold
        {
            get
            {
                return this.fontParentBold;
            }
            set
            {
                this.fontParentBold = value;
            }
        }

        [DefaultValue(0), RefreshProperties(RefreshProperties.Repaint), Browsable(true), Category("Appearance-Extended")]
        public int GroupByColumnIndex
        {
            get
            {
                return this.groupByColumnIndex;
            }
            set
            {
                this.groupByColumnIndex = value;
            }
        }

        [Category("Appearance-Extended"), Browsable(true), DefaultValue("ID")]
        public string IDColumnName
        {
            get
            {
                return this.iDColumnName;
            }
            set
            {
                this.iDColumnName = value;
            }
        }

        [Browsable(true), RefreshProperties(RefreshProperties.Repaint), DefaultValue(1), Category("Appearance-Extended")]
        public int ImageIndexChild
        {
            get
            {
                return this.imageIndexChild;
            }
            set
            {
                this.imageIndexChild = value;
            }
        }

        [Category("Appearance-Extended"), DefaultValue(0), RefreshProperties(RefreshProperties.Repaint), Browsable(true)]
        public int ImageIndexParent
        {
            get
            {
                return this.imageIndexParent;
            }
            set
            {
                this.imageIndexParent = value;
            }
        }

        [Category("Appearance-Extended"), Browsable(true)]
        public System.Windows.Forms.ImageList ImageList
        {
            get
            {
                return this._imageList;
            }
            set
            {
                this._imageList = value;
            }
        }

        [Browsable(true), DefaultValue(true), Category("Appearance-Extended")]
        public bool IsOneLevel
        {
            get
            {
                return this.isOneLevel;
            }
            set
            {
                this.isOneLevel = value;
            }
        }

        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content), Category("Appearance-Extended"), Editor(typeof(CollectionEditor), typeof(UITypeEditor)), Browsable(true), Description("The collection of root nodes in the treelist.")]
        public TreeGridNodeCollection Nodes
        {
            get
            {
                return this._root.Nodes;
            }
        }

        [DefaultValue("ParentID"), Browsable(true), Category("Appearance-Extended")]
        public string ParentIDColumnName
        {
            get
            {
                return this._parentIDColumnName;
            }
            set
            {
                this._parentIDColumnName = value;
            }
        }

        [Category("Appearance-Extended"), Browsable(true)]
        public int RowCount
        {
            get
            {
                return this.Nodes.Count;
            }
            set
            {
                for (int i = 0; i < value; i++)
                {
                    this.Nodes.Add(new TreeGridNode());
                }
            }
        }

        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
        public DataGridViewRowCollection Rows
        {
            get
            {
                return base.Rows;
            }
        }

        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
        public DataGridViewRow RowTemplate
        {
            get
            {
                return base.RowTemplate;
            }
            set
            {
                base.RowTemplate = value;
            }
        }

        [Browsable(true), Category("Appearance-Extended"), DefaultValue(true)]
        public bool ShowLines
        {
            get
            {
                return this._showLines;
            }
            set
            {
                if (value != this._showLines)
                {
                    this._showLines = value;
                    base.Invalidate();
                }
            }
        }

        [Category("Appearance-Extended"), Browsable(true), DefaultValue(false)]
        public bool UseParentRelationship
        {
            get
            {
                return this.useParentRelationship;
            }
            set
            {
                this.useParentRelationship = value;
            }
        }

        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), EditorBrowsable(EditorBrowsableState.Never)]
        public bool VirtualMode
        {
            get
            {
                return false;
            }
            set
            {
                throw new NotSupportedException("The TreeGridView does not support virtual mode");
            }
        }

        [DefaultValue(false), Category("Appearance-Extended"), Description("Causes nodes to always show as expandable. Use the NodeExpanding event to add nodes."), Browsable(true)]
        public bool VirtualNodes
        {
            get
            {
                return this._virtualNodes;
            }
            set
            {
                this._virtualNodes = value;
            }
        }

        private static class Win32Helper
        {
            public const int WM_KEYDOWN = 0x100;
            public const int WM_SETREDRAW = 11;
            public const int WM_SYSKEYDOWN = 260;

            [DllImport("USER32.DLL", CharSet=CharSet.Auto)]
            public static extern bool PostMessage(HandleRef hwnd, int msg, IntPtr wparam, IntPtr lparam);
            [DllImport("USER32.DLL", CharSet=CharSet.Auto)]
            public static extern IntPtr SendMessage(HandleRef hWnd, int msg, int wParam, int lParam);
            [DllImport("USER32.DLL", CharSet=CharSet.Auto)]
            public static extern IntPtr SendMessage(HandleRef hWnd, int msg, IntPtr wParam, IntPtr lParam);
        }
    }
}

